perm filename VERIFY.SAI[SYS,HE]1 blob
sn#004214 filedate 1972-11-02 generic text, type T, neo UTF8
COMMENT ⊗ VALID 00013 PAGES
RECORD PAGE DESCRIPTION
00001 00001
00005 00002 BEGIN "VERIFY"
00008 00003 ⊃ INITIALIZES SENSITIVITY CONTROL
00012 00004 ⊃ GENERAL ACCOMODATION ROUTINE
00015 00005 ⊃ READ IN GLOBAL STRUCTURE FROM DISK
00017 00006 ⊃ THIS IS THE VERIFICATION PROCEDURE
00020 00007 ⊃ COMPUTES CONTRAST ACHEIVED UNDER PRESENT ACCOMODATION
00022 00008 ⊃ ACCOMODATES FOR MAX
00024 00009 ⊃ LINE SIGNIFICANCE FUNCTION
00030 00010 ⊃ CHOOSES COLOR FILTER FOR BEST CONTRAST. (WIDE, HALF WAY DOWN EDGE)
00032 00011 ⊃ HERE BEGINS THE BODY OF EDGEVERIFY
00034 00012 ⊃ THIS IS THE MAIN LOOP OF EDGEVERIFY
00036 00013 ⊃ MAIN PROGRAM BEGINS HERE
00041 ENDMK
⊗;
BEGIN "VERIFY"
REQUIRE "PREAMB.SAI[SYS,HE]" SOURCE_FILE;
REQUIRE "HELIB[1,3]" LIBRARY;
REQUIRE 500 STRING_SPACE;
REQUIRE -1 NEW_ITEMS;
REQUIRE "DPYSUB.HDR[SYS,HE]" SOURCE_FILE;
REQUIRE "SQRT[SYS,HE]" LOAD_MODULE;
EXTERNAL PROCEDURE FADCHG(REAL X,Y;PROCEDURE F);
EXTERNAL PROCEDURE FRDCHG(REAL X,Y;PROCEDURE F);
EXTERNAL REAL PROCEDURE SQRT(REAL X);
EXTERNAL PROCEDURE TVIN;
EXTERNAL PROCEDURE PRDUMP;
EXTERNAL PROCEDURE INTPNT;
EXTERNAL INTEGER PROCEDURE GETPNT(INTEGER X,Y);
EXTERNAL INTEGER PROCEDURE DDACO(INTEGER DAC);
EXTERNAL PROCEDURE CWHEEL(INTEGER I);
EXTERNAL INTEGER PROCEDURE GETCOR(INTEGER SIZE);
EXTERNAL PROCEDURE RELCOR(INTEGER IOWD);
EXTERNAL INTEGER TSERVO,TVWORD,BCLIP,TCLIP,FLINE,LLINE,RSIDE,LSIDE,STVFL,IND,TVCAM;
INTEGER I, FRAME, DEBUGX, FRA, I1, I2, XX, YY, X, Y, L, W;
DEFINE CRLF="'15&'12", ⊃="COMMENT ",TVRESET="STVFL←0", SAFEX="",
TTEST="3.087", LENG="4", WIDTH="2";
⊃ LENG AND WIDTH CONTROL OPERATOR SIZE AND SHAPE (UNLESS CHANGED IN DEBUGGING MODE)
WIDTH IS THE NUMBER OF POINTS PERPENDICULAR TO THE EDGE
LENG IS THE NUMBER OF POINTS PARALLEL TO THE EDGE
LENG=1, WIDTH=5 IS THE PURE EDGE OPERATOR
LENG=5, WIDTH=1 IS THE PURE LINE OPERATOR;
PRELOAD_WITH [12] 0;
REAL ARRAY CONVLT[0:3,1:3]; ⊃ CONTRAST,TARGET,AUTOTARGET FOR 4 COLOR FILTERS
0-RED,1-BLUE,2-GREEN,3-WHITE;
INTEGER ARRAY HISTO[0:16];
⊃ SET DAC AND READ A-D WITH TYPE OUT;
SIMPLE INTEGER PROCEDURE DACO(INTEGER I);
BEGIN INTEGER J;
J ← DDACO(I);
OUTSTR("DAC SET TO "&CVS(I)&" AD= "&CVS(J)&CRLF);
TVRESET;
RETURN(J);
END;
⊃ INITIALIZES SENSITIVITY CONTROL;
SIMPLE PROCEDURE SENSINIT;
BEGIN LABEL HALF, LOUT, L2;
INTEGER UDAC, LDAC, I, J, K, TST, PT, CURAD;
IF ¬AUTOCAL_ACC THEN
L2: BEGIN "INIT"
FOR I←2 STEP 1 UNTIL 61 DO TABLE_ACC[I] ← -1;
AUTO_ACC ← 60;
TABLE_ACC[LDAC←62] ← DACO(LDAC);
TABLE_ACC[UDAC←1] ← DACO(UDAC);
IF ABS(TABLE_ACC[62]-TABLE_ACC[1])<100 THEN
BEGIN
OUTSTR("SENSITIVITY CONTROL IS HUNG"&CRLF&"TYPE ANY CHAR TO CONT."&CRLF);
INCHWL;
GO TO L2;
END;
AUTOCAL_ACC ← TRUE;
GO TO HALF;
END "INIT";
TABLE_ACC[1] ← CURAD ← DACO(1);
IF ABS(CURAD-(J←TABLE_ACC[AUTO_ACC]))<40 THEN GO TO LOUT;
IF CURAD<J THEN
BEGIN "HI"
UDAC ← 1;
LDAC ← AUTO_ACC;
AUTO_ACC ← AUTO_ACC-1;
GO TO HALF;
END "HI";
TST ← 10000;
FOR I←62 STEP -1 UNTIL AUTO_ACC DO IF (J←TABLE_ACC[I])≥0∧(K←ABS(CURAD-J))<TST THEN
BEGIN
IF K<20 THEN BEGIN AUTO_ACC ← I; GO TO LOUT; END;
TST ← K; PT ← I;
END;
J ← IF K←(TABLE_ACC[PT]>CURAD) THEN -1 ELSE 0;
TST ← PT;
WHILE TABLE_ACC[TST←TST+J]<0 DO;
IF K THEN BEGIN LDAC←PT; UDAC←TST; END ELSE
BEGIN LDAC←TST; UDAC←PT; END;
IF LDAC-UDAC<2 THEN
LOUT: BEGIN "OUT"
SENSCAL_ACC ← TRUE;
CHANGE_ACC ← FALSE;
IF AUTO_ACC≠DAC_ACC THEN DACO(AUTO_ACC);
OUTSTR("AUTO TARGET SET AT "&CVS(AUTO_ACC)&CRLF);
RETURN;
END "OUT";
HALF: I ← (LDAC+UDAC) DIV 2;
CURAD ← TABLE_ACC[I] ← DACO(I);
IF (J←ABS(CURAD-TABLE_ACC[LDAC])<40)∨ABS(CURAD-TABLE_ACC[UDAC])<50 THEN
BEGIN "L1"
IF J THEN BEGIN DACO(AUTO_ACC←LDAC); GO TO LOUT; END;
UDAC ← I;
IF LDAC-UDAC<2 THEN
BEGIN
IF CURAD-TABLE_ACC[I-1]>50 THEN DACO(AUTO_ACC←I-1) ELSE AUTO_ACC←I;
GO TO LOUT;
END;
GO TO HALF;
END "L1";
LDAC ← I;
AUTO_ACC ← LDAC-1;
IF LDAC-UDAC<2 THEN GO TO LOUT;
GO TO HALF;
END;
⊃ SET CLIP LEVELS TO JUST INCLUDE THE RANGE OF INTENSITIES GIVEN;
SIMPLE BOOLEAN PROCEDURE CLIPSET(REFERENCE INTEGER INT, INT2);
BEGIN INTEGER BIG, T, B;
T←TCLIP+(BCLIP-TCLIP)*(15-(INT MAX INT2))%14;
B←BCLIP-(BCLIP-TCLIP)*(INT MIN INT2)%14;
IF T>B THEN
BEGIN
OUTSTR("CLIP LEVELS REVERSED - CLIPRANGE"&CRLF);
TCLIP↔BCLIP;
END;
IF TCLIP=T∧BCLIP=B THEN RETURN(TRUE);
TCLIP←T;
BCLIP ← B;
TVRESET;
RETURN(FALSE);
END;
⊃ GENERAL ACCOMODATION ROUTINE;
⊃ XX, YY MUST BE SET BEFORE CALLING;
SIMPLE BOOLEAN PROCEDURE TEST1;
BEGIN
IF ¬STVFL THEN TVIN;
I1 ← GETPNT(X, Y);
I2 ← GETPNT(XX, YY);
RETURN(ABS(I1-I2)≥11);
END;
PROCEDURE ACC;
BEGIN SAFEX BOOLEAN ARRAY TDAC[0:63];
INTEGER I, J, MX, MN, AD, K, MDAC;
LABEL L1, A, C;
⊃ QUICK TEST FOR AUTOTARGET LIMIT;
IF BCLIP=7∧AUTO_ACC=DAC_ACC∧¬CHANGE_ACC∧BCLIP=TCLIP THEN RETURN;
⊃ INIT LEGAL DAC TABLE;
MDAC ← 2;
TDAC[63] ← FALSE;
TDAC[AUTO_ACC+1] ← FALSE;
TDAC[AUTO_ACC] ← TRUE;
ARRBLT(TDAC[AUTO_ACC+1],TDAC[AUTO_ACC],61-AUTO_ACC);
IF BCLIP<7∨TCLIP THEN
BEGIN
BCLIP ← 7;
TCLIP ← 0;
TVRESET;
END;
IF TVCAM≠1 THEN GO TO A;
⊃ ADJUST DAC AS NECESSARY AND POSSIBLE;
L1: IF TEST1 THEN GO TO A;
MN ← I1 MIN I2;
MX ← I1 MAX I2;
IF (¬MN∧MX=15)∨(MN>0∧MX<15)∨(MX-MN)≥11 THEN GO TO A;
IF MN THEN
BEGIN "MN"
FOR I←1 STEP 1 UNTIL MDAC+1 DO IF ¬TDAC[DAC_ACC+I] THEN DONE;
I ← I-1;
IF ¬I THEN GO TO A;
J ← DAC_ACC;
TABLE_ACC[DAC_ACC+I] ← DACO(DAC_ACC+I);
WHILE TDAC[J] DO BEGIN TDAC[J]←FALSE;J←J-1;END;
GO TO L1;
END "MN";
AD ← 0;
FOR I←1 STEP 1 UNTIL MDAC+1 DO IF ¬TDAC[DAC_ACC-I] THEN DONE;
I ← I-1;
IF ¬I THEN
BEGIN
IF (DAC_ACC-1>AUTO_ACC)∨¬CHANGE_ACC THEN GO TO A;
I ← MDAC ← 1;
TABLE_ACC[DAC_ACC] ← AD ← DDACO(-1);
END;
J ← DAC_ACC;
I ← TABLE_ACC[DAC_ACC-I] ← DACO(DAC_ACC-I);
IF AD THEN
BEGIN "AD"
IF ABS(AD-I)<10 THEN
BEGIN
DAC_ACC ← J;
CHANGE_ACC ← FALSE;
GO TO A;
END;
TDAC[AUTO_ACC←DAC_ACC] ← TRUE;
TDAC[AUTO_ACC-1] ← FALSE;
END "AD";
WHILE TDAC[J] DO BEGIN TDAC[J] ← FALSE; J←J+1; END;
GO TO L1;
⊃ ADJUST CLIPS FOR PROPER OUTPUT;
A: WHILE ¬CLIPSET(I1,I2)∧-TEST1∧TCLIP≠BCLIP DO;
OUTSTR("TCLIP="&CVS(TCLIP)&" BCLIP="&CVS(BCLIP)&CRLF);
END;
⊃ READ IN GLOBAL STRUCTURE FROM DISK;
PROCEDURE READ_FROM_DISK;
BEGIN
DEFINE DATA="14",XFER(A,B)="ARRYIN (DATA,A,B)";
INTEGER BREAK,EOF,MAXOBJ,I,J;
SAFE REAL ARRAY CAMERA_MODEL[1:10,1:3];
ITEMVAR X,Y;
OPEN(DATA,"DSK",'10,2,0,200,BREAK,EOF);
OUTSTR("ENTER SCENE NUMBER: " &CRLF);
LOOKUP (DATA,"EDG"&INCHWL&".SCN",EOF);
XFER ("CAMERA_MODEL[1,1]",30);
XFER (MAXOBJ,1);
FOR I←1 STEP 1 UNTIL MAXOBJ DO
BEGIN
X←GLOBAL NEW;
PUT X IN BLOBS;
XFER (J,1); COMMENT SIZE OF ARRAY;
IF J THEN BEGIN REAL ARRAY GG[1:2,0:J];
XFER("GG[1,0]",(J+1)*2);
Y←GLOBAL NEW(GG);
GLOBAL MAKE BOUNDARY⊗X≡Y;
END;
XFER (J,1);
IF J THEN BEGIN REAL ARRAY GG[1:4,0:J];
XFER("GG[1,0]",(J+1)*4);
Y←GLOBAL NEW(GG);
GLOBAL MAKE INSIDE_EDGES⊗X≡Y;
END;
END;
OUTSTR("MODEL COMPLETED"&CRLF);
RELEASE (DATA);
END;
⊃ THIS IS THE VERIFICATION PROCEDURE;
REAL PROCEDURE EDGEVERIF(INTEGER X1,Y1,X2,Y2);
BEGIN "VERIF"
INTEGER P1X,P2X,P1Y,P2Y,W2,CLP1,CLP2,RIG,BOT,REACNT,TCNT,N,T,I;
REAL XINC,YINC,REA,QNOISE,TX,TY,LW,LNM,A,B,C,D,AV1,AV2,OFFSET,DI,OFFSAVE,OFFH,SHFT;
SAFEX INTEGER ARRAY VALUES[1:L*W*2];
BOOLEAN OUTSID;
⊃ RETURN X,Y COORDINATES OF POINT IN RECTANGLE GIVEN BY:
TX,TY ARE COORDINATES OF POINT ON LINE
OFFSET IS OFFSET FROM LINE
DI IS INDEX FROM OFFSET
I,J ARE INDICIES IN RECTANGE (0≤I≤L-1, 0≤J≤W-1)
COORDINATES PUT IN X AND Y
OUTSID SET TRUE IF POINT OUTSIDE BUFFER, NOT CHANGED OTHERWISE;
SIMPLE PROCEDURE SCAN(REAL DI;INTEGER I, J);
BEGIN REAL IND;
IND ← OFFSET+DI+(IF DI>0 THEN J ELSE -J);
X ← TX+D*IND+C*I-A+.5;
Y ← TY-C*IND+D*I-B+.5;
IF ¬(0≤X≤RIG∧0≤Y≤BOT) THEN
BEGIN
OUTSID ← TRUE;
OUTSTR("POINT OUTSIDE BUFFER - VERIFY"&CRLF);
END;
END;
⊃ SET UP CONSTANTS FOR SCANNING THE OPERATOR;
SIMPLE PROCEDURE SCANSET;
BEGIN REAL TF;
A ← P2Y-P1Y;
B ← P2X-P1X;
TF ← SQRT(A↑2+B↑2);
C ← B/TF;
D ← A/TF;
N ← TF/L;
IF N>15.0 THEN N←15.0;
XINC ← B/N;
YINC ← A/N;
A ← C*L/2.0;
B ← D*L/2.0;
W2 ← W%2;
IF W2<1 THEN W2←1;
END;
⊃ COMPUTES CONTRAST ACHEIVED UNDER PRESENT ACCOMODATION;
SIMPLE REAL PROCEDURE CNTRST;
BEGIN "CNTR"
INTEGER I, J;
REAL AVG1,AVG2;
SIMPLE PROCEDURE HSTGRM;
BEGIN "HSTG" INTEGER I, INTN;
FOR I←0 STEP 1 UNTIL 16 DO HISTO[I]←0;
FOR I←L-1 STEP -1 UNTIL 0 DO FOR J←W-1 STEP -1 UNTIL 0 DO
BEGIN
SCAN(DI,I,J);
IF OUTSID THEN RETURN;
HISTO[INTN←GETPNT(X,Y)]←HISTO[INTN]+1;
END;
FOR I←0 STEP 1 UNTIL 15 DO HISTO[16]←HISTO[16]+HISTO[I];
END"HSTG";
IF ¬STVFL THEN TVIN;
OUTSID ← FALSE;
CLP1 ← CLP2 ← 0;
HSTGRM;
IF OUTSID THEN RETURN(0);
AVG1←0;
FOR I←1 STEP 1 UNTIL 15 DO AVG1←AVG1+I*HISTO[I];
AVG1←AVG1/HISTO[16];
CLP1←HISTO[0]+HISTO[15];
DI←-DI;
HSTGRM;
DI←-DI;
IF OUTSID THEN RETURN(0);
AVG2←0;
FOR I←1 STEP 1 UNTIL 15 DO AVG2←AVG2+I*HISTO[I];
AVG2←AVG2/HISTO[16];
CLP2←HISTO[0]+HISTO[15];
AVG2←AVG2-AVG1;
RETURN(ABS(AVG2));
END "CNTR";
⊃ ACCOMODATES FOR MAX;
SIMPLE REAL PROCEDURE FINECALL;
BEGIN
OUTSID ← FALSE;
SCAN(DI,L/2,W2);
XX ← X;
YY ← Y;
SCAN(-DI,L/2,W2);
IF OUTSID THEN RETURN(0);
ACC;
RETURN(CNTRST);
END;
⊃ DEBUGGING DISPLAY;
PROCEDURE DPYSHW(REAL VAL1, VAL2);
BEGIN INTEGER I,J, K;
SAFE INTEGER ARRAY BUF[1:100];
SETFORMAT(10,3);
DPYSET(BUF);
DPYBRT(1);
DPYBIG(2);
FADCHG(0,0,AIVECT);
J ← GETPOG;
FOR I←L-1 STEP -1 UNTIL 0 DO FOR K←W-1 STEP -1 UNTIL 0 DO
BEGIN
SCAN(DI,I,K);
FRDCHG(X+LSIDE,Y+FLINE,RPOINT);
SCAN(-DI,I,K);
FRDCHG(X+LSIDE,Y+FLINE,RPOINT);
END;
FRDCHG(100,300,RIVECT);
DPYSST("V1="&CVF(VAL1)&" V2="&CVF(VAL2));
DPYOUT(J);
I ← INCHWL;
IF I="P" THEN PRDUMP;
IF I="N" THEN BEGIN DEBUGX ← FALSE; RELPOG(FRA); END;
RELPOG(J);
END;
⊃ LINE SIGNIFICANCE FUNCTION;
SIMPLE REAL PROCEDURE TSIG;
BEGIN "STT"
REAL SP, SM, SPQ, SMQ, SIGP, SIGM, I1, I2;
INTEGER I, J, K;
LABEL OUTS;
K ← OUTSID ← SP ← SM ← SPQ ← SMQ ← 0;
IF ¬STVFL THEN TVIN;
FOR I← L-1 STEP -1 UNTIL 0 DO FOR J←W-1 STEP -1 UNTIL 0 DO
BEGIN
SCAN(DI,I,J);
IF OUTSID THEN RETURN(0);
I1 ← VALUES[K←K+1]←GETPNT(X,Y);
SCAN(-DI,I,J);
IF OUTSID THEN RETURN(0);
I2 ← VALUES[K←K+1]←GETPNT(X,Y);
SP ← SP+I1;
SPQ ← SPQ+I1↑2;
SM ← SM+I2;
SMQ ← SMQ+I2↑2;
END;
AV1 ← SP/LW;
AV2 ← SM/LW;
SIGP ← (SPQ-SP↑2/LW)/LNM MAX QNOISE;
SIGM ← (SMQ-SM↑2/LW)/LNM MAX QNOISE;
IF DEBUGX THEN
BEGIN
SETFORMAT(4,0);
FOR K←1 STEP 2 UNTIL LW*2 DO OUTSTR(CVS(VALUES[K])&" ");
OUTSTR("|||||| ");
FOR K←2 STEP 2 UNTIL LW*2 DO OUTSTR(CVS(VALUES[K])&" ");
OUTSTR(CRLF);
END;
RETURN(ABS((SP-SM)/(SQRT((SIGP+SIGM)/LW)*LW)));
END "STT";
⊃ CHOOSES COLOR FILTER FOR BEST CONTRAST. (WIDE, HALF WAY DOWN EDGE)
SENS TUNED TO PEAK CONTRAST FOR EACH FILTER;
SIMPLE PROCEDURE COLINT;
BEGIN "COLINT"
LABEL MX;
REAL HIAVG;
INTEGER I,IMAX;
DEFINE COLWHEEL(I)="IF COLFILT_ACC≠I THEN
BEGIN INTEGER N;
CWHEEL(COLFILT_ACC←I);
N←20000; WHILE N>0 DO N←N-1;
END";
DI←4.0;
TX ← P1X + XINC*N/2;
TY ← P1Y + YINC*N/2;
FOR IND←3,1,0,2 DO
BEGIN "COLCHG"
COLWHEEL(IND);
IF ¬CONVLT[IND,3] THEN
BEGIN
SENSINIT;
CONVLT[IND,3] ← AUTO_ACC;
END;
CONVLT[IND,1]←FINECALL;
CONVLT[IND,2]←DAC_ACC;
OUTSTR((CASE IND OF ("RED","BLUE","GREEN","CLEAR")) & "FILTER: ");
OUTSTR("CONTRAST="&CVF(CONVLT[IND,1])&" DAC_ACC="&CVF(CONVLT[IND,2])&CRLF);
IF CONVLT[IND,1]≥11.0 THEN GO TO MX;
END "COLCHG";
IMAX←3;
HIAVG←CONVLT[3,1];
FOR I←2 STEP -1 UNTIL 0 DO
IF CONVLT[I,1]>HIAVG THEN
BEGIN HIAVG←CONVLT[I,1]; IMAX←I; END;
COLWHEEL(IMAX);
DACO(CONVLT[IMAX,2]);
AUTO_ACC←CONVLT[IMAX,3];
MX: OUTSTR("BEST FILTER IS "&(CASE IND OF ("RED","BLUE","GREEN","CLEAR")) & CRLF);
END "COLINT";
⊃ HERE BEGINS THE BODY OF EDGEVERIFY;
LW ← L*W;
LNM ← LW-1;
FLINE ← ((Y1 MIN Y2)-20) MAX 15;
LLINE ← ((Y1 MAX Y2)+20) MIN 250;
LSIDE ← ((X1 MIN X2)-20) MAX 15;
RSIDE ← ((X1 MAX X2)+20) MIN 330;
BOT ← LLINE-FLINE+1;
RIG ← RSIDE-LSIDE+1;
P1X ← X1-LSIDE;
P2X ← X2-LSIDE;
P1Y ← Y1-FLINE;
P2Y ← Y2-FLINE;
I ← ((RIG DIV 9)+1)*BOT;
TVWORD ← GETCOR(I);
INTPNT;
TVRESET;
IF DEBUGX THEN
BEGIN
SAFE INTEGER ARRAY BUF[1:20];
DPYSET(BUF);
FADCHG(LSIDE,FLINE,AIVECT);
FRDCHG(RSIDE,FLINE,RVECT);
FRDCHG(RSIDE,LLINE,RVECT);
FRDCHG(LSIDE,LLINE,RVECT);
FRDCHG(LSIDE,FLINE,RVECT);
DPYOUT(FRA);
END;
CWHEEL(6);
IF IND≠3 THEN
BEGIN
CWHEEL(COLFILT_ACC←3);
I←20000;
WHILE I>0 DO I←I-1;
IF ¬CONVLT[3,3] THEN CHANGE_ACC ← TRUE;
END;
IF CHANGE_ACC∨CONVLT[3,3]≠AUTO_ACC THEN FOR I←0 STEP 1 UNTIL 2 DO CONVLT[I,3]←0;
IF ¬SENSCAL_ACC∨CHANGE_ACC∧TVCAM=1 THEN SENSINIT;
CONVLT[3,3] ← AUTO_ACC;
SCANSET;
COLINT;
DI←1.5;
TCNT ← OFFSET←REACNT←0;
QNOISE ← ((1+BCLIP-TCLIP)/256)↑2;
TX ← P1X+XINC;
TY ← P1Y+YINC;
⊃ THIS IS THE MAIN LOOP OF EDGEVERIFY;
FOR T←4 STEP 1 UNTIL N DO
BEGIN "LOOP"
LABEL L1,L2;
TCNT←TCNT+1;
TX ← TX+XINC;
TY ← TY+YINC;
REA←TSIG;
IF DEBUGX THEN DPYSHW(REA,OFFSET);
SHFT ← 0;
OFFH ← OFFSAVE←OFFSET;
IF REA<TTEST THEN
BEGIN "ACO"
IF TCLIP≠BCLIP∨¬(.5≤AV1≤14.5)∨¬(.5≤AV2≤14.5) THEN
BEGIN
FINECALL;
QNOISE ← ((1+BCLIP-TCLIP)/256)↑2;
REA ← TSIG;
IF DEBUGX THEN DPYSHW(REA,OFFSET);
IF REA≥TTEST THEN GO TO L1;
END;
WHILE TRUE DO
BEGIN "SHIFT"
SHFT ← IF SHFT≤0 THEN ABS(SHFT) + 1.0 ELSE -SHFT;
OFFSET ← OFFH+SHFT;
IF ABS(OFFSET)>5.0∨ABS(SHFT)>2.0 THEN
BEGIN
OFFSET ← OFFSAVE;
GO TO L2;
END;
REA ← TSIG;
IF DEBUGX THEN DPYSHW(REA,OFFSET);
IF REA≥TTEST THEN
BEGIN
OFFSAVE ← OFFSET;
DONE;
END;
END "SHIFT";
END "ACO";
L1: REACNT←REACNT+1;
L2: OFFSET ← OFFSAVE;
END "LOOP";
RELCOR(TVWORD);
IF COLFILT_ACC≠3 THEN
BEGIN
CWHEEL(COLFILT_ACC←3);
DACO(AUTO_ACC←CONVLT[3,3]);
END;
RETURN(REACNT/TCNT);
END "VERIF";
⊃ MAIN PROGRAM BEGINS HERE;
MESSAGE PROCEDURE VERIFY(INTEGER X1, Y1, X2, Y2; REFERENCE REAL CONF);
CONF ← EDGEVERIF(X1, Y1, X2, Y2);
PUT_DATA(0,0,"VERIFY");
YES_VER ← TRUE;
FRA ← FRAME ← -1;
L ← LENG;
W ← WIDTH;
WHILE TRUE DO
BEGIN
IF RUN∧¬DEB_VER THEN
BEGIN INTEGER MESS;
DEBUGX ← FALSE;
MESS ← GET_ENTRY('160,NULL,"VERIFY","VERIFY");
QUEUE('600,MESS);
END ELSE BEGIN INTEGER X1, Y1, X2, Y2, M, SAVE, I, J;
SAFE INTEGER ARRAY DISP[1:400];
REAL ARRAY CORNER[1:300,1:2];
REAL X, Y, CONF;
REAL ARRAY ITEMVAR INS, OUTS,O;
SIMPLE PROCEDURE STR(REAL X,Y);
BEGIN INTEGER I;
FOR I←1 STEP 1 UNTIL M DO IF X=CORNER[I,1]∧Y=CORNER[I,2] THEN RETURN;
CORNER[M←M+1,1] ← X;
CORNER[M,2] ← Y;
END;
OUTSTR("DEBUG?"&CRLF);
DEBUGX ← INCHWL="Y";
IF RUN THEN
BEGIN
OUTSTR("VERIFY WAITING"&CRLF);
INCHWL;
END ELSE READ_FROM_DISK;
SETFORMAT(0,5);
M ← 0;
IF DEBUGX∧FRA<0 THEN FRA←GETPOG;
IF FRAME<0 THEN FRAME ← GETPOG;
DPYSET(DISP);
DPYBRT(1);
DPYBIG(2);
FOREACH O|OεBLOBS DO
BEGIN DEFINE GOUT(X,Y)="GLOBAL DATUM(OUTS)[X,Y]",
GIN(X,Y)="GLOBAL DATUM(INS)[X,Y]";
FOREACH OUTS|GLOBAL BOUNDARY⊗O≡OUTS DO
BEGIN
I ← GOUT(1,0);
FADCHG(GOUT(1,I),GOUT(2,I),AIVECT);
FOR J←1 STEP 1 UNTIL I DO
BEGIN
X ← GOUT(1,J);
Y ← GOUT(2,J);
FRDCHG(X,Y,RVECT);
STR(X,Y);
END;
END;
FOREACH INS|GLOBAL INSIDE_EDGES⊗O≡INS DO
BEGIN
I ← GIN(1,0);
FADCHG(0,0,AIVECT);
FOR J←1 STEP 1 UNTIL I DO
BEGIN
X ← GIN(1,J);
Y ← GIN(2,J);
FRDCHG(X,Y,RIVECT);
STR(X,Y);
X ← GIN(3,J);
Y ← GIN(4,J);
FRDCHG(X,Y,RVECT);
STR(X,Y);
END;
END;
END;
FOR I ← 1 STEP 1 UNTIL M DO
BEGIN
FADCHG(CORNER[I,1],CORNER[I,2],AIVECT);
DPYSST(CVS(I));
END;
DPYBRT(7);
DPYBIG(6);
DPYOUT(FRAME);
WHILE TRUE DO
BEGIN
IF DEBUGX THEN
BEGIN
OUTSTR("CHANGE OPERATOR?"&CRLF);
IF INCHWL="Y" THEN
BEGIN
OUTSTR("LENGTH="&CRLF);
L ← CVD(INCHWL);
OUTSTR("WIDTH="&CRLF);
W ← CVD(INCHWL);
END;
END;
OUTSTR("POINT 1="&CRLF);
IF ¬(I←CVD(INCHWL)) THEN DONE;
OUTSTR("POINT 2="&CRLF);
J ← CVD(INCHWL);
SETFORMAT(20,3);
OUTSTR(CVF(CORNER[I,1])&CVF(CORNER[I,2])&CVF(CORNER[J,1])&CVF(CORNER[J,2])&CRLF);
CONF ← EDGEVERIF(CORNER[I,1],CORNER[I,2],CORNER[J,1],CORNER[J,2]);
OUTSTR("CONF="&CVF(CONF)&CRLF);
END;
HYDPOG(FRAME);
END;
END;
END "VERIFY";